import { Request, Response } from 'express';
import * as itemsService from '../models/itemsService';
import { Items } from '../types/items';

// 添加items数据 
export const addItems = async (req: Request, res: Response): Promise<void> => {
    try {
        // 从请求体中获取 items 数据
        const itemsData: Items = req.body;
        // 验证必填字段
        const requiredFields: (keyof Items)[] = ['name', 'production_date', 'expiry_date', 'quantity', 'user_id', 'family_id'];
        const missingFields = requiredFields.filter(field => !itemsData[field]);
        if (missingFields.length > 0) {
            res.status(400).json({
                message: '缺少必填字段',
                missingFields,
            });
            return;
        }

        // 验证数据格式
        if (typeof itemsData.name !== 'string' || typeof itemsData.quantity !== 'number') {
            res.status(400).json({
                message: '字段格式不正确',
                errors: [
                    itemsData.name && typeof itemsData.name !== 'string' ? 'name 必须是字符串' : null,
                    itemsData.quantity && typeof itemsData.quantity !== 'number' ? 'quantity 必须是数字' : null,
                ].filter(Boolean),
            });
            return;
        }

        // 确保日期字段是有效的日期
        if (isNaN(Date.parse(itemsData.production_date)) || isNaN(Date.parse(itemsData.expiry_date))) {
            res.status(400).json({
                message: '日期格式不正确',
                errors: [
                    isNaN(Date.parse(itemsData.production_date)) ? 'production_date 格式不正确' : null,
                    isNaN(Date.parse(itemsData.expiry_date)) ? 'expiry_date 格式不正确' : null,
                ].filter(Boolean),
            });
            return;
        }

        // 确保生产日期小于过期日期
        const productionDate = new Date(itemsData.production_date);
        const expiryDate = new Date(itemsData.expiry_date);

        if (productionDate >= expiryDate) {
            res.status(400).json({
                message: '生产日期必须早于过期日期',
            });
            return;
        }

        // 调用 addItems 函数，添加新的 item
        const newItem = await itemsService.addItems(itemsData);
        res.status(201).json({
            message: '添加成功',
            data: newItem,
        });
    } catch (error: any) {
        console.error('Error adding item:', error);
        res.status(500).json({
            message: '无法添加项目',
            error: error.message,
        });
    }
};

// 根据指定的参数获取数据详情
export const getItemsByParams = async (req: Request, res: Response): Promise<void> => {
    try {
        // 从请求查询参数中获取数据
        const {
            name,
            near_expiry_days,
            price,
            quantity,
            attributes,
            created_at,
            updated_at,
            category_id,
            user_id,
            family_id,
            limit,
            offset
        } = req.query;

        // 构造查询条件
        const query = {
            name: name ? String(name) : undefined,
            near_expiry_days: near_expiry_days ? Number(near_expiry_days) : undefined,
            price: price ? Number(price) : undefined,
            quantity: quantity ? Number(quantity) : undefined,
            attributes: attributes ? String(attributes) : undefined,
            created_at: created_at ? String(created_at) : undefined,
            updated_at: updated_at ? String(updated_at) : undefined,
            category_id: category_id ? Number(category_id) : undefined,
            user_id: user_id ? Number(user_id) : undefined,
            family_id: family_id ? Number(family_id) : undefined,
        };

        // 调用服务层函数查询数据
        // 确保 limit 和 offset 是有效的数字
        const parsedLimit = limit ? Number(limit) : 10; // 默认值为 10
        const parsedOffset = offset ? Number(offset) : 0; // 默认值为 0

        // 调用服务层函数查询数据
        const items = await itemsService.getItemsByParams(query, parsedLimit, parsedOffset);

        // 返回成功响应
        res.status(200).json({
            message: '查询成功',
            data: items,
        });
    } catch (error: any) {
        console.error('Error querying items:', error);

        // 返回错误响应
        res.status(500).json({
            message: '查询失败',
            error: error.message,
        });
    }
};

// 修改items数据 
export const updateItem = async (req: Request, res: Response): Promise<void> => {
    try {
        // 获取 URL 参数中的 item ID
        const { id } = req.body;
        // 验证 ID 是否有效
        if (!id || isNaN(Number(id))) {
            res.status(400).json({ message: '无效的 ID 参数' });
            return;
        }
        // 获取请求体中的更新字段
        const updates = req.body;
        // 验证是否传递了更新字段
        if (!updates || Object.keys(updates).length === 0) {
            res.status(400).json({ message: '未提供需要更新的字段' });
            return;
        }
        // 调用服务层函数更新数据
        const affectedRows = await itemsService.updateItem(Number(id), updates);
        if (affectedRows > 0) {
            res.status(200).json({ message: '修改成功' });
        } else {
            res.status(404).json({ message: '未找到匹配的记录' });
        }
    } catch (error: any) {
        console.error('Error updating item:', error);
        res.status(500).json({ message: '无法修改 item 数据', error: error.message });
    }
};

// 获取items列表 根据不同的参数进行获取
export const getItemsList = async (req: Request, res: Response): Promise<void> => {
    console.log('req.query', req.query)
    try {
        // 从请求查询参数中获取数据
        const {
            family_id,
            name,
            production_date,
            expiry_date,
            price,
            quantity,
            category_id,
            page,
            limit,
            attributes,
            status
        } = req.query;

        // 验证必传参数 family_id
        if (!family_id) {
            res.status(400).json({ message: 'family_id1 是必传参数' });
            return;
        }

        // 构造查询条件
        const query = {
            family_id: family_id,
            name: name ? String(name) : undefined,
            production_date: production_date ? String(production_date) : undefined,
            expiry_date: expiry_date ? String(expiry_date) : undefined,
            price: price !== undefined ? Number(price) : undefined,
            quantity: quantity !== undefined ? Number(quantity) : undefined,
            category_id: category_id !== undefined ? Number(category_id) : undefined,
            attributes: attributes ? String(attributes) : undefined,
            status: status ? Number(status) : undefined,
        };

        // 分页参数，默认第 1 页，每页返回 10 条
        const pageNumber = page ? Number(page) : 1;
        const pageSize = limit ? Number(limit) : 10;

        // 计算偏移量
        const offset = (pageNumber - 1) * pageSize;

        // 调用服务层获取数据
        const { items, total } = await itemsService.getItemsList(query, pageSize, offset);

        // 返回成功响应
        res.status(200).json({
            message: '查询成功',
            data: items,
            pagination: {
                total,
                page: pageNumber,
                limit: pageSize,
                totalPages: Math.ceil(total / pageSize),
            },
        });
    } catch (error: any) {
        console.error('Error getting items list:', error);

        // 返回错误响应
        res.status(500).json({ message: '无法获取 items 数据', error: error.message });
    }
};

// 根据参数获取price的总值
export const getItemsPriceController = async (req: Request, res: Response) => {
    try {
        console.log('查询参数：', req.query)
        const { family_id, attributes } = req.query;
        if (!family_id) {
            res.status(400).json({ message: 'family_id 是必传参数' });
            return;
        }
        const query = {
            family_id: family_id,
            attributes: attributes ? String(attributes) : undefined, // 可选的 attributes 参数
        };
        const { items, totalPrice } = await itemsService.getAllItemsPrice(query);
        res.status(200).json({
            message: '查询成功',
            dataNUmber: items.length, //数量
            totalPrice,
        });
    }
    catch (error: any) {
        console.error('Error getting items list:', error);

        // 返回错误响应
        res.status(500).json({ message: '无法获取 items 数据', error: error.message });
    }
};

// 更新物品数量并根据数量与阈值判断状态
export const setUserItemThresholdController = async (req: Request, res: Response) => {
    const { item_id, threshold, family_id } = req.body;

    // 校验请求参数
    if (typeof item_id !== 'number' || typeof threshold !== 'number' || typeof family_id !== 'string') {
        res.status(400).json({ message: '无效的参数' });
        return
    }

    try {
        // 调用服务层函数设置阈值
        console.log(item_id, threshold, family_id)
        const affectedRows = await itemsService.setUserItemThreshold(item_id, threshold, family_id);
        if (affectedRows > 0) {
            res.status(200).json({ message: '修改成功' });
        } else {
            res.status(404).json({ message: '未找到匹配的记录' });
        }
    } catch (error) {
        res.status(500).json({ message: '服务器内部错误1' });
        return
    }
};

// 更新物品数量 
export const updateQuantityController = async (req: Request, res: Response) => {
    const { user_id, item_id, quantity, family_id } = req.body;

    // 校验请求参数
    if (typeof user_id !== 'number' || typeof item_id !== 'number' || typeof quantity !== 'number' || typeof family_id !== 'number') {
        res.status(400).json({ message: '无效的参数' });
        return
    }

    try {
        // 调用服务层函数更新物品数量和状态
        await itemsService.updateItemQuantity(user_id, item_id, quantity, family_id);
        res.status(200).json({ message: '物品数量更新成功' });
        return
    } catch (error) {
        res.status(500).json({ message: '服务器内部错误' });
        return
    }
};